<html>
<head><meta charset="utf-8"><title>recursive solver: recursion and completeness · wg-traits · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/index.html">wg-traits</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html">recursive solver: recursion and completeness</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="200826592"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200826592" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mark Drobnak <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200826592">(Jun 14 2020 at 17:56)</a>:</h4>
<p>I was reading up on the recursive solver and found the <a href="https://rust-lang.github.io/chalk/book/recursive.html#recursion-and-completeness">Recursion and Completeness</a> section of the recursive solver docs. It shows a program and goal which is not solvable by the recursive solver, but is solvable using SLG (i.e., the recursive solver gets ambiguity while SLG gets a unique solution).</p>
<p>Is this a fundamental problem, or is there some method to work around it?</p>



<a name="200828048"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200828048" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200828048">(Jun 14 2020 at 18:37)</a>:</h4>
<p>If I understand it correctly, this is a fundamental "problem" with the recursive solver</p>



<a name="200828170"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200828170" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200828170">(Jun 14 2020 at 18:40)</a>:</h4>
<p>Hmm</p>



<a name="200828183"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200828183" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200828183">(Jun 14 2020 at 18:41)</a>:</h4>
<p>Well, I <em>thought</em> that the current trait solver fails to find a solution here, so I went and made a playground: <a href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=e25912b11a57df522b7c0ad2bb05451f">https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=e25912b11a57df522b7c0ad2bb05451f</a></p>



<a name="200828186"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200828186" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200828186">(Jun 14 2020 at 18:41)</a>:</h4>
<p>But I guess rustc is smart to resolve this</p>



<a name="200828192"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200828192" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200828192">(Jun 14 2020 at 18:41)</a>:</h4>
<p>If I remember correctly, this might be due to how rustc handles the ambiguity</p>



<a name="200828943"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200828943" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mark Drobnak <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200828943">(Jun 14 2020 at 19:00)</a>:</h4>
<p>For the recursive solver to be viable I assume we need to fix this issue, right?</p>



<a name="200833702"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200833702" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Matthew Jasper <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200833702">(Jun 14 2020 at 21:08)</a>:</h4>
<p>Am I doing this wrong? The following test passes:</p>
<div class="codehilite"><pre><span></span><code><span class="cp">#[test]</span><span class="w"></span>
<span class="k">fn</span> <span class="nf">not_really_ambig</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="n">test</span><span class="o">!</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">        </span><span class="n">program</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">            </span><span class="k">struct</span> <span class="nb">Vec</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w"></span>

<span class="w">            </span><span class="k">trait</span><span class="w"> </span><span class="n">A</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w"></span>
<span class="w">            </span><span class="k">trait</span><span class="w"> </span><span class="n">B</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w"></span>

<span class="w">            </span><span class="k">impl</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">A</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="nb">Vec</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="k">where</span><span class="w"> </span><span class="n">T</span>: <span class="nc">A</span><span class="p">,</span><span class="w"> </span><span class="n">T</span>: <span class="nc">B</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w"></span>

<span class="w">            </span><span class="k">impl</span><span class="w"> </span><span class="n">A</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="kt">u32</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w"></span>
<span class="w">            </span><span class="k">impl</span><span class="w"> </span><span class="n">B</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="kt">u32</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w"></span>

<span class="w">            </span><span class="k">impl</span><span class="w"> </span><span class="n">A</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="kt">i32</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w"></span>
<span class="w">        </span><span class="p">}</span><span class="w"></span>

<span class="w">        </span><span class="n">goal</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">            </span><span class="n">exists</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="nb">Vec</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span>: <span class="nc">A</span><span class="w"> </span><span class="p">}</span><span class="w"></span>
<span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="n">yields</span><span class="p">[</span><span class="n">SolverChoice</span>::<span class="n">recursive</span><span class="p">()]</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">            </span><span class="s">&quot;Unique; substitution [?0 := Uint(U32)], lifetime constraints []&quot;</span><span class="w"></span>
<span class="w">        </span><span class="p">}</span><span class="w"></span>
<span class="w">    </span><span class="p">}</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>



<a name="200833785"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200833785" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200833785">(Jun 14 2020 at 21:11)</a>:</h4>
<p>huh</p>



<a name="200833832"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200833832" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200833832">(Jun 14 2020 at 21:12)</a>:</h4>
<p><span class="user-mention" data-user-id="116009">@nikomatsakis</span> was there a different example?</p>



<a name="200834635"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200834635" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Matthew Jasper <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200834635">(Jun 14 2020 at 21:34)</a>:</h4>
<p>Maybe there was supposed to be an <code>impl B for i8 { }</code> in the example?</p>



<a name="200835374"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200835374" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200835374">(Jun 14 2020 at 21:54)</a>:</h4>
<p>I don't see how that would change things?</p>



<a name="200836869"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200836869" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Matthew Jasper <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200836869">(Jun 14 2020 at 22:35)</a>:</h4>
<p>In the example from the book, the unique impl of <code>B</code> can be used to make progress, force unifying <code>?1 = u32</code> which allows progress on <code>?1: A</code>, which is now <code>u32: A</code>.  If both <code>A</code> and <code>B</code> have multiple impls, then neither alone can make progress, so the recursive solver can't make progress.</p>



<a name="200838617"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200838617" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200838617">(Jun 14 2020 at 23:29)</a>:</h4>
<p>That indeed is ambiguous</p>



<a name="200838845"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200838845" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200838845">(Jun 14 2020 at 23:35)</a>:</h4>
<div class="codehilite"><pre><span></span><code>#[test]
fn not_really_ambig() {
    test! {
        program {
            struct Vec&lt;T&gt; { }

            trait A { }
            trait B { }

            impl&lt;T&gt; A for Vec&lt;T&gt; where T: A, T: B { }

            impl A for u32 { }
            impl B for u32 { }

            impl A for i32 { }
            impl B for i8 { }
        }

        goal {
            exists&lt;T&gt; { Vec&lt;T&gt;: A }
        } yields[SolverChoice::slg_default()] {
            &quot;Unique; substitution [?0 := Uint(U32)], lifetime constraints []&quot;
        } yields[SolverChoice::recursive()] {
            &quot;Ambiguous&quot;
        }
    }
}
</code></pre></div>



<a name="200955105"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200955105" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200955105">(Jun 15 2020 at 22:48)</a>:</h4>
<p>yes I gave the wrong example -- <span class="user-mention" data-user-id="129457">@Florian Diebold</span> pointed this out earlier -- but I forgot to fix it</p>



<a name="200955128"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200955128" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200955128">(Jun 15 2020 at 22:48)</a>:</h4>
<p><a href="#narrow/stream/144729-wg-traits/topic/documenting.20the.20recursive.20solver/near/199737532">link to our conversation earlier</a></p>



<a name="200955133"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200955133" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200955133">(Jun 15 2020 at 22:48)</a>:</h4>
<p>I'd welcome a PR fixing the example :)</p>



<a name="200961404"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200961404" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Mark Drobnak <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200961404">(Jun 16 2020 at 00:23)</a>:</h4>
<p><a href="https://github.com/rust-lang/chalk/pull/528">https://github.com/rust-lang/chalk/pull/528</a></p>
<p>I'm still curious about this being a fundamental issue. If rustc currently handles this, then at some point if we want to use the recursive solver we will have to fix this. Therefore, either it can't be a fundamental issue (or we could tweak the solver design to fix it) and we continue pursuing the recursive solver, or it is a fundamental issue and we should not continue pursuing the recursive solver.</p>



<a name="200994848"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200994848" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Florian Diebold <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200994848">(Jun 16 2020 at 10:10)</a>:</h4>
<p>as far as I can see, rustc <em>doesn't</em> handle this: <a href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=00fe0459959ad1d1223bae9154fce2dd">playground</a> (even if there's just one impl for <code>A</code> and <code>B</code> each)</p>
<p>Jack's playground has no variables, in which case there's no ambiguity (the goal is just <code>Vec&lt;u32&gt;: A</code>, that's easy to solve)</p>



<a name="200996941"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200996941" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Matthew Jasper <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200996941">(Jun 16 2020 at 10:39)</a>:</h4>
<p>Rustc always treats <code>_: A</code> as ambiguous. It handles <code>{{integer}}: A</code> though (using <code>vec![0]</code> instead of <code>Vec::new()</code>).</p>



<a name="200997466"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200997466" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Florian Diebold <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200997466">(Jun 16 2020 at 10:46)</a>:</h4>
<p>the example still doesn't work with an integer variable though</p>



<a name="200997524"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200997524" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Florian Diebold <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200997524">(Jun 16 2020 at 10:46)</a>:</h4>
<p>it <em>does</em> work with an integer variable if there's only one applicable impl for both A and B, but that's fine</p>



<a name="200997561"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200997561" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Florian Diebold <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200997561">(Jun 16 2020 at 10:47)</a>:</h4>
<p>(although it'll require some tweaks to the floundering logic to handle)</p>



<a name="200997958"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200997958" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Florian Diebold <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200997958">(Jun 16 2020 at 10:52)</a>:</h4>
<p>e.g. <a href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=f7ef4768d9d73201abd5c02079fa0e75">playground</a></p>



<a name="200998627"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/200998627" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Matthew Jasper <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#200998627">(Jun 16 2020 at 11:01)</a>:</h4>
<p>That's what I meant. I don't think that there are any real problems for the recursive solver here.</p>



<a name="201057530"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/201057530" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Jack Huey <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#201057530">(Jun 16 2020 at 18:43)</a>:</h4>
<p>Oh whoops, bad example :D</p>



<a name="201059484"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/144729-wg-traits/topic/recursive%20solver%3A%20recursion%20and%20completeness/near/201059484" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> nikomatsakis <a href="https://rust-lang.github.io/zulip_archive/stream/144729-wg-traits/topic/recursive.20solver.3A.20recursion.20and.20completeness.html#201059484">(Jun 16 2020 at 18:59)</a>:</h4>
<p>no problem relative to rustc, anyway, since it already takes a "recursive-solver-like" approach</p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>